// pages/task-list/index.js
import useAuthBehavior from '~/behaviors/useAuth';
import { isTokenExpiredError, handleTokenExpiredError, checkAndHandleAuthError } from '~/utils/auth-error-handler';

import {
  getCurrentUserId
} from '../../utils/user-helper.js';

// 封面图路径配置（WXS会自动处理为云存储URL）
const COVER_PATH_PREFIX = '/static/list-covers/';
const COVER_EXTENSION = '.png';


Page({
  behaviors: [useAuthBehavior],

  /**
   * 页面的初始数据
   */
  data: {
    tasks: [],
    loading: false,
    refreshing: false,
    scrollTop: 0, // 👈 新增：记录滚动距离
    stats: {
      total: 0,
      running: 0,
      completed: 0,
      failed: 0
    },
    pagination: {
      currentPage: 1,
      pageSize: 20, // 改为 10 条，适应视频预览布局
      hasMore: false,
      hasPrev: false
    }
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad() {
    // 检查登录状态，如果未登录则跳转到登录页
    if (!this.requireLogin({
        message: '请先登录后查看任务列表'
      })) {
      return;
    }

    this.loadTasks(1);
  },

  onScroll(e) {
    this.setData({
      scrollTop: e.detail.scrollTop
    });
  },

  // 页面级下拉刷新处理
  onPullDownRefresh() {
    console.log('🔄 页面下拉刷新触发');
    this.loadTasks(1).then(() => {
      // 停止系统下拉刷新动画
      wx.stopPullDownRefresh();
    });
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 设置tab-bar选中状态
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        value: 'task-list'
      });
    }
    this.loadTasks(this.data.pagination.currentPage);
  },

  // 加载任务列表
  async loadTasks(page = 1) {
    if (this.data.loading) return;

    this.setData({
      loading: true
    });

    try {
      console.log('🔍 开始加载任务列表...', { page });

      // 获取当前用户ID
      const userId = getCurrentUserId();
      if (!userId) {
        wx.showToast({
          title: '请先登录',
          icon: 'none'
        });
        this.setData({
          loading: false
        });
        return;
      }

      // 直接请求50条任务
      const res = await wx.cloud.callFunction({
        name: 'video-task',
        data: {
          action: 'list',
          userId: userId,
          page: 1,
          limit: 50  // 固定请求50条
        }
      });

      // 检查是否为token过期错误
      if (checkAndHandleAuthError(res, {
        customMessage: '任务访问权限已过期，请重新登录'
      })) {
        this.setData({ loading: false });
        return;
      }

      console.log('📋 任务列表响应:', res);

      if (res.result && res.result.success) {
        const tasks = res.result.data?.tasks || [];

        console.log('📋 加载到的任务数据:', tasks.length, '条');

        // 处理任务数据，添加显示标签和新的字段
        const processedTasks = tasks.map(task => {
          // 将 rendering 状态映射为 running
          const displayStatus = task.status === 'rendering' ? 'running' : task.status;
          
          // 状态文本映射
          const statusTextMap = {
            'running': '生成中',
            'completed': '已完成',
            'failed': '失败',
            'waiting': '等待中'
          };
          
          const processedTask = {
            ...task,
            displayStatus: displayStatus,
            statusText: statusTextMap[displayStatus] || '未知',
            
            // 时间相关
            createTimeLabel: this.formatTime(task.createTime),
            updateTimeLabel: task.updateTime ? this.formatTime(task.updateTime) : null,
            timeAgo: this.getTimeAgo(task.createdAt || task.createTime), // 几分钟前

            // 任务标题和描述
            title: task.title || '未命名视频',
            shortDescription: this.generateShortDescription(task),

            // 视频相关字段
            videoUrl: task.result?.videoUrl || task.result?.video_url || '',
            coverUrl: this.getCoverUrl(task), // 同步调用，返回相对路径
            hasCover: true, // 总是有封面（真实或默认）
            hasVideo: !!(task.result?.videoUrl || task.result?.video_url)
          };
          return processedTask;
        });

        // 计算统计数据
        const stats = this.calculateStats(processedTasks);

        this.setData({
          tasks: processedTasks,
          stats: stats
        });

        console.log('✅ 任务列表加载成功，共', processedTasks.length, '个任务');
        console.log('📊 统计数据:', stats);
      } else {
        console.error('❌ 加载任务列表失败:', res.result);
        wx.showToast({
          title: res.result?.message || '加载失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('❌ 加载任务列表异常:', error);
      
      // 检查异常信息是否包含token过期错误
      if (isTokenExpiredError(error.message)) {
        handleTokenExpiredError({
          customMessage: '任务访问权限已过期，请重新登录'
        });
        this.setData({ loading: false });
        return;
      }
      
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      });
    } finally {
      this.setData({
        loading: false,
        refreshing: false // 确保下拉刷新状态也被重置
      });
    }
  },

  // 上一页
  prevPage() {
    const currentPage = this.data.pagination.currentPage;
    if (currentPage > 1) {
      this.loadTasks(currentPage - 1);
    }
  },

  // 下一页
  nextPage() {
    const { currentPage, hasMore } = this.data.pagination;
    if (hasMore) {
      this.loadTasks(currentPage + 1);
    }
  },

  // 计算统计数据
  calculateStats(tasks) {
    const stats = {
      total: tasks.length,  // 总任务数
      running: 0,
      completed: 0,
      failed: 0
    };

    tasks.forEach(task => {
      // 将历史 rendering 状态映射为 running
      const displayStatus = task.displayStatus || task.status;
      
      switch (displayStatus) {
        case 'running':
          stats.running++;
          break;
        case 'completed':
          stats.completed++;
          break;
        case 'failed':
          stats.failed++;
          break;
      }
    });

    return stats;
  },

  // 跳转到任务详情
  goToDetail(e) {
    const taskId = e.currentTarget.dataset.taskId;
    console.log('🔗 点击任务卡片，taskId:', taskId);

    if (taskId) {
      console.log('🔗 正在跳转到任务详情页面...');
      wx.navigateTo({
        url: `/packageTask/pages/task-detail/index?taskId=${taskId}`
      });
    } else {
      console.error('❌ taskId 为空，无法跳转');
      wx.showToast({
        title: '任务ID不存在',
        icon: 'none'
      });
    }
  },

  // 刷新单个任务状态
  async refreshTask(e) {
    const taskId = e.currentTarget.dataset.taskId;
    console.log('🔄 刷新任务:', taskId);

    // 获取当前用户ID
    const userId = getCurrentUserId();
    if (!userId) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    try {
      const res = await wx.cloud.callFunction({
        name: 'video-task',
        data: {
          action: 'query',
          userId: userId, // 传入用户ID
          taskId: taskId
        }
      });

      // 检查是否为token过期错误
      if (checkAndHandleAuthError(res, {
        customMessage: '任务访问权限已过期，请重新登录'
      })) {
        return;
      }

      if (res.result && res.result.success) {
        // 更新任务列表中的对应任务
        const tasks = this.data.tasks.map(task => {
          if (task.taskId === taskId) {
            return {
              ...task,
              ...res.result.data,
              updateTimeLabel: res.result.data.updateTime ? this.formatTime(res.result.data.updateTime) : null
            };
          }
          return task;
        });

        // 重新计算统计数据
        const stats = this.calculateStats(tasks);

        this.setData({
          tasks: tasks,
          stats: stats
        });

        wx.showToast({
          title: '刷新成功',
          icon: 'success'
        });
      }
    } catch (error) {
      console.error('❌ 刷新任务失败:', error);
      wx.showToast({
        title: '刷新失败',
        icon: 'none'
      });
    }
  },

  // 重试失败的任务
  async retryTask(e) {
    const taskId = e.currentTarget.dataset.taskId;

    wx.showModal({
      title: '重新生成',
      content: '确定要重新生成这个视频吗？',
      success: async (res) => {
        if (res.confirm) {
          try {
            // 找到原任务数据
            const originalTask = this.data.tasks.find(task => task.taskId === taskId);
            if (!originalTask) {
              wx.showToast({
                title: '任务不存在',
                icon: 'none'
              });
              return;
            }

            // 获取当前用户ID
            const userId = getCurrentUserId();
            if (!userId) {
              wx.showToast({
                title: '请先登录',
                icon: 'none'
              });
              return;
            }

            // 重新提交任务
            const retryRes = await wx.cloud.callFunction({
              name: 'video-task',
              data: {
                action: 'submit',
                userId: userId, // 传入用户ID
                data: {
                  taskType: originalTask.taskType,
                  content: originalTask.content,
                  otherContent: originalTask.otherContent,
                  speaker: originalTask.speaker,
                  emotion: originalTask.emotion,
                  style: originalTask.style,
                  images: originalTask.images,
                  materialType: originalTask.materialType
                }
              }
            });

            // 检查是否为token过期错误
            if (checkAndHandleAuthError(retryRes, {
              customMessage: '任务提交权限已过期，请重新登录'
            })) {
              return;
            }

            if (retryRes.result && retryRes.result.success) {
              wx.showToast({
                title: '重新生成成功',
                icon: 'success'
              });

              // 刷新任务列表
              this.loadTasks(this.data.pagination.currentPage);
            } else {
              wx.showToast({
                title: retryRes.result?.message || '重新生成失败',
                icon: 'none'
              });
            }
          } catch (error) {
            console.error('❌ 重试任务失败:', error);
            wx.showToast({
              title: '重新生成失败',
              icon: 'none'
            });
          }
        }
      }
    });
  },

  // 分享视频
  shareVideo(e) {
    const taskId = e.currentTarget.dataset.taskId;
    const task = this.data.tasks.find(t => t.taskId === taskId);

    if (task && task.result && task.result.videoUrl) {
      wx.showShareMenu({
        withShareTicket: true,
        menus: ['shareAppMessage', 'shareTimeline']
      });

      wx.showToast({
        title: '可以分享给朋友了',
        icon: 'success'
      });
    }
  },

  // 跳转到创建页面
  goToCreate() {
    wx.navigateTo({
      url: '/packageTask/pages/task-submit/index'
    });
  },

  // 格式化时间
  formatTime(timestamp) {
    if (!timestamp) return '';

    const date = new Date(timestamp);
    const now = new Date();
    const diff = now - date;

    // 一分钟内
    if (diff < 60 * 1000) {
      return '刚刚';
    }

    // 一小时内
    if (diff < 60 * 60 * 1000) {
      const minutes = Math.floor(diff / (60 * 1000));
      return `${minutes}分钟前`;
    }

    // 一天内
    if (diff < 24 * 60 * 60 * 1000) {
      const hours = Math.floor(diff / (60 * 60 * 1000));
      return `${hours}小时前`;
    }

    // 超过一天，显示具体日期
    const month = date.getMonth() + 1;
    const day = date.getDate();
    const hour = date.getHours();
    const minute = date.getMinutes();

    return `${month}月${day}日 ${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`;
  },

  // 生成几分钟前的时间标签
  getTimeAgo(timeStr) {
    if (!timeStr) return '未知时间';

    let date;
    if (timeStr instanceof Date) {
      date = timeStr;
    } else if (typeof timeStr === 'string') {
      date = new Date(timeStr);
    } else {
      return '未知时间';
    }

    if (isNaN(date.getTime())) {
      return '未知时间';
    }

    const now = new Date();
    const diff = now.getTime() - date.getTime();

    // 1分钟内
    if (diff < 60 * 1000) {
      return '刚刚';
    }

    // 1小时内
    if (diff < 60 * 60 * 1000) {
      const minutes = Math.floor(diff / (60 * 1000));
      return `${minutes}分钟前`;
    }

    // 1天内
    if (diff < 24 * 60 * 60 * 1000) {
      const hours = Math.floor(diff / (60 * 60 * 1000));
      return `${hours}小时前`;
    }

    // 1周内
    if (diff < 7 * 24 * 60 * 60 * 1000) {
      const days = Math.floor(diff / (24 * 60 * 60 * 1000));
      return `${days}天前`;
    }

    // 超过1周，显示具体日期
    const month = date.getMonth() + 1;
    const day = date.getDate();
    return `${month}月${day}日`;
  },


  // 生成简短描述
  generateShortDescription(task) {
    let content = task.parameters.content || task.parameters.topic
    // 优先使用内容作为描述
    if (content) {
      const cleanContent = content.trim().replace(/\s+/g, ' ');
      if (cleanContent.length <= 30) {
        return cleanContent;
      }
      return cleanContent.substring(0, 30) + '...';
    }

    // 如果没有内容，根据参数生成描述
    const parts = [];

    if (task.parameters.speaker) {
      parts.push(task.parameters.speaker);
    }

    if (task.taskType) {
      parts.push(task.taskType);
    }

    if (parts.length > 0) {
      return parts.join(' · ');
    }

    return '';
  },

  // 获取封面URL（优先真实封面，其次根据taskType的默认封面）
  // 返回相对路径，由WXS自动转换为云存储URL
  getCoverUrl(task) {
    // 1. 优先使用真实的视频封面
    const realCover = task.result?.coverUrl || task.result?.cover_url;
    if (realCover) {
      return realCover;
    }

    // 2. 如果没有真实封面，根据 taskType 使用默认封面
    const taskType = task.taskType;
    if (taskType) {
      // 返回相对路径，WXS会自动转换为云存储URL
      return COVER_PATH_PREFIX + taskType + COVER_EXTENSION;
    }

    // 3. 如果连 taskType 都没有，返回默认封面
    return COVER_PATH_PREFIX + 'default' + COVER_EXTENSION;
  }
});